COMMENT ⊗   VALID 00004 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	\input UNIT.TEX[RLL,RDG]
C00046 00003	\SlotEntry <{ToParseParts} {FSingleton FunctionType} {This value is used by each
C00075 00004	\StartIndex
C00082 ENDMK
C⊗;
\input UNIT.TEX[RLL,RDG]

\ClassEntry <{Anything} 1 {The topmost node, in all the hierarchies.}>
\CFact SubClass@
AnyAT&U AnyAbstractThing AnyCT&U AnyConcreteThing AnyUnit>
\CFact Direct Examples@AnyClassOfObjects>
\SlotsFor {thing}

\SlotEntry <{Isa} {FSet (UnitType (*P AnyClassOfObjects))} {This primitive slot 
is the fundamental hierarchical link in this system, specifying those classes to
 which this unit belongs. Note that its format is SET - hence this system can handle
 a DAG structure; better for our purposes than a tree.}>
\SFact Inverse@Examples>

\SlotEntry <{Characteristics} {FSet NonNILType} {This lists some essential characteristics
 of this unit. (Not currently in use.)}> \SFact HighLevelDefn@(Unioning FunctionCharacter FormatCharacter)>

\SlotEntry <{Descr} {FSingleton NonNILType} {This describes this unit. (It is used
 to generate this document.)}>
\SlotEntry <{AllIsas} {FSet UnitType} {This specifies each class to which this unit
 belongs. (It includes each \Slot (SuperClass) \ of this unit's \Slot (Isa) \ slot.
)}> \SFact Inverse@AllExamples>
\SFact HighLevelDefn@(Composition SuperClass* Isa)>

\SlotEntry <{AllGenls} {FSet UnitType} {This points to a list of those units which
 are somehow more general than this unit.}> \SFact Inverse@AllSpecs>
\SFact HighLevelDefn@(Unioning Prototypes (OneOf SuperClass* SuperTypEx* SuperSlot* GenlAct*))>

\SlotEntry <{AllSpecs} {FSet UnitType} {This lists every unit which is somehow more
 precise than this unit.}> \SFact Inverse@AllGenls>
\SFact HighLevelDefn@(Unioning AllTypicalExampleOfs (OneOf SubClass* SubTypEx* SubSlot* SpecAct*))>

\SlotEntry <{Prototypes} {FSet (UnitType (*P AnyArchetype))} {This points to each
 typical example of this unit, not necessarily in order of increasing generality.
}> \SFact Inverse@AllTypicalExampleOfs>
\SFact HighLevelDefn@(Composition TypicalExample AllIsas)>

\SlotEntry <{Specializations} {FSet UnitType} {This points to each unit which ``specializes''
 this unit.}> \SFact Inverse@Generalizations>
\SFact HighLevelDefn@(OneOf SubSlot SpecAct SubTypEx SubDT SubClass)>

\SlotEntry <{OrderedPrototypes} {FOrderedSet UnitType} {Enumerates the prototypes
 of this unit in order of increasing generality (i.e. \Unit (TypicalDog) \ would
 precede \Unit (TypicalAnimal) .)}> \SFact HighLevelDefn@(PutInOrder Prototypes SuperTypEx* NIL MembForOrdPro)>

\ClassEntry <{AnyAT&U} 2 {This is a HACK - to deal with the units in this system,
 which represent both some abstract object (NOT in the world,) and themselves...
}> \CFact SuperClass@Anything>
\CFact SubClass@AnyIntensionalObject>

\ctrline{\it The slots appropriate for all ``AT&U''s are those defined for each of: (
\Unit (AnyUnit)\  \Unit (AnyAbstractThing)\ ).}

\ClassEntry <{AnyIntensionalObject} 3 {Descendants of this unit describe some
 entity in the world intensionally -- as opposed to directly referring to in.}> \CFact SuperClass@
AnyAT&U AnyCT&U>
\CFact SubClass@AnyArchetype AnyDescriptor AnyUnitForSlot AnyVariable>

\ClassEntry <{AnyArchetype} 4 {Every typical example of some class is an archetype,
 and descends from this unit.}> \CFact SuperClass@AnyIntensionalObject>
\hmode{\qquad There are currently 111 examples.}\par
\SlotsFor {Archetype}

\SlotEntry <{NewPossibleSlots} {FSet SlotType} {This lists the names of slots which
 are meaningful for every ``instance'' of this typical example. Furthermore, this
 is the highest place where this slot is meaningful (hence the ``{\sl new}ness''
 of the name.)}> \SFact Inverse@MakesSenseFor>
\SFact HighLevelDefn@(Composition (Soften NewPossibleSlots) MyComposeOf)>

\SlotEntry <{TypicalExampleOf} {FSingleton (UnitType (*P AnyClassOfObjects))} {Refers
 back, from the typical example unit, to the class of elements it typifies.}> \SFact Inverse@TypicalExample>

\SlotEntry <{SuperTypEx} {FSet UnitType} {This denotes the relation connecting \Unit
 (TypicalDog) \ to \Unit (TypicalAnimal) \ -- i.e. a superset relation holds between
 the elements each (respectively) typifies.}> \SFact Inverse@SubTypEx>
\SFact HighLevelDefn@(Composition TypicalExample SuperClass TypicalExampleOf)>

\SlotEntry <{SubTypEx} {FSet UnitType} {See \Slot (SuperTypEx) .}> \SFact Inverse@SuperTypEx>
\SFact HighLevelDefn@(Composition TypicalExample SubClass TypicalExampleOf)>

\SlotEntry <{PossibleSlots} {FSet UnitType} {This is obsolete - and will soon be
 deleted.}> \SFact HighLevelDefn@(Composition NewPossibleSlots SuperTypEx*)>

\SlotEntry <{SuperTypEx*} {FSet UnitType} {This is the transitive closure of \Slot
 (SuperTypEx) .}> \SFact Inverse@SubTypEx*>
\SFact HighLevelDefn@(Composition TypicalExample SuperClass* TypicalExampleOf)>

\SlotEntry <{SubTypEx*} {FSet (UnitType (*P AnyArchetype))} {This is the transitive
 closure of \Slot (SubTypEx) .}> \SFact Inverse@SuperTypEx*>
\SFact HighLevelDefn@(Composition TypicalExample SubClass* TypicalExampleOf)>

\ClassEntry <{AnyDescriptor} 5 {This will eventually hold descriptors -- a whole
 class of entities which will have to be defined...}> \CFact SuperClass@AnyIntensionalObject
>

\ClassEntry <{AnyUnitForSlot} 6 {At times, there is more than just one ``morsel''
 of information needed to describe the value of some unit's slot. RLL then devotes
 an entire unit to hold this information. Such units descend from this \Unit (AnyUnitForSlot.
)}> \CFact SuperClass@AnyIntensionalObject>
\SlotsFor {UnitForSlot}

\SlotEntry <{*vaLue*} {FSingleton NonNILType} {When a unit is allocated to store
 facts about the value of a slot, the actual value of that slot, if any, is kept
 in the \Slot (*vaLue*) \ slot of that sub unit.}> \SFact HighLevelDefn@(Application (Composition Defn LivesInSlot) LivesInUnit)>

\ClassEntry <{AnyVariable} 7 {This class contains the universally or existentially
 bound variables. Note that this is a META description of said units.}> \CFact SuperClass@
AnyIntensionalObject>

\ClassEntry <{AnyAbstractThing} 8 {Instances refer to intangible objects; as 
opposed to concrete things (such as real world people or units) .}> \CFact SuperClass@
Anything>

\ClassEntry <{AnyCT&U} 9 {This is a HACK - to deal with the units in this system,
 which represent both some object in the world, and themselves...}> \CFact SuperClass@
Anything>
\CFact SubClass@AnyClassOfObjects AnyDatatype AnyDecomposableObject AnyFormat AnyInheritance
 AnyIntensionalObject AnyOverhead AnyProcess AnyUnit AnyUser>

\ctrline{\it The slots appropriate for all ``CT&U''s are those defined for each of: (
\Unit (AnyUnit)\  \Unit (AnyConcreteThing)\ ).}

\ClassEntry <{AnyClassOfObjects} 10 {Every member of this class is itself a set.
}> \CFact SuperClass@AnyCT&U>
\CFact SubClass@AnyClassOfPhysicalObjects AnyFiniteSet AnySetOfClauses AnySymbol
>
\hmode{\qquad There are currently 120 examples.}\par
\SlotsFor {ClassOfObjects}

\SlotEntry <{TypicalExample} {FSingleton (UnitType (*P AnyArchetype))} {This points
 from a class to an abstract entity which holds default information about members
 of this class.}> \SFact Inverse@TypicalExampleOf>

\SlotEntry <{DomainOf} {FSet (UnitType (*P AnyFunction))} {If a function takes one
 or more elements of this class, as arguments, that function is stored on the \LispFn
 (DomainOf) \ slot of the unit representing that class.}> \SFact Inverse@Domain>

\SlotEntry <{RangeOf} {FSet (UnitType (*P AnyFunction))} {If a function maps into
 this class (or a space having this class as one dimension,) that function is stored
 on the \LispFn (RangeOf) \ slot of the unit representing that class.}> \SFact Inverse@Range>

\SlotEntry <{IntensionalExamples} {FSet UnitType} {Fill in later.}>
\SlotEntry <{StdExamples} {FSet UnitType} {This slot basically represents the vanilla
 ``\EPSILON'' relationship, between an extensional object, and a represented set.
}>
\SlotEntry <{SuperClass} {FSet (UnitType (*P AnyClassOfObjects))} {This points from
 a class, C, to each superset of C, D\Sub (i) . That is, x \EPSILON C => x \EPSILON
 D\Sub (i) , for all elements x, and all sets, D\Sub (i) .}> \SFact Inverse@SubClass>

\SlotEntry <{SubClass} {FSet UnitType} {This points from a class, C, to each subset
 of C.}> \SFact Inverse@SuperClass>

\SlotEntry <{Examples} {FSet UnitType} {This points from a class to each member 
of that class. (Both constant and variable.)}> \SFact Inverse@Isa>
\SFact HighLevelDefn@(Unioning IntensionalExamples StdExamples)>

\SlotEntry <{TotalSoFar} {FSingleton IntegerType} {Fill in later.}>
\SlotEntry <{SuperClass*} {FSet UnitType} {A list of a unit's SuperClass, THEIR 
SuperClass, etc.}> \SFact Inverse@SubClass*>
\SFact HighLevelDefn@(Starring SuperClass)>

\SlotEntry <{SubClass*} {FSet UnitType} {A list of a unit's SubClass, THEIR SubClass,
 etc.}> \SFact Inverse@SuperClass*>
\SFact HighLevelDefn@(Starring SubClass)>

\SlotEntry <{AllExamples} {FSet UnitType} {This points from a class to a list of
 members of this class. (\Slot (Examples) \ only pointed to elements immediately
 a member of some set --- this will follow their \Slot (SuperClass) \ links as well,
 to more accurately represent an ``\EPSILON'' relation.)}> \SFact Inverse@AllIsas>
\SFact HighLevelDefn@(Composition Examples SubClass*)>

\SlotEntry <{GenlsModels} {FSet (UnitType (*P AnyArchetype))} {This is used for 
several of the inheritances. The prototypes of every example of some class include
 that class's \Slot (GenlsModels) .}> \SFact HighLevelDefn@(Composition TypicalExample SuperClass*)>

\ClassEntry <{AnyDatatype} 11 {Every datatype (used for building up type specifications,
) descends from this.}> \CFact SuperClass@AnyCT&U>
\hmode{\qquad There are currently 12 examples.}\par
\SlotsFor {Datatype}

\SlotEntry <{EqualDTSpec} {FSet (FListN (UnitType (*P AnyDatatype)) UnrestrictedType
)} {This helps relate one datatype to another -- by defining a set of equivalent
 datatype-datarange pairs.}>
\SlotEntry <{VerifyType} {FSingleton FunctionType} {\UnitSlot (DT:VerifyType) is
 a predicate, returning non{\LispFn (NIL) } for all elements which qualify in this
 datatype.}>
\SlotEntry <{GenerateAll} {FSingleton FunctionType} {\UnitSlot (DT:GenerateAll) 
returns a list of all members of the datatype, \Unit (DT) .}>
\SlotEntry <{SuperDT} {FSet (UnitType (*P AnyDatatype))} {This points to the list
 of more general datatypes -- i.e. those which contain a superset of this datatype's
 members.}> \SFact Inverse@SubDT>

\SlotEntry <{SubDT} {FSet (UnitType (*P AnyDatatype))} {\UnitSlot (DT:SubDt) points
 to Datatypes which accept a subset of those accepts by the datatype \Unit (DT) 
.}> \SFact Inverse@SuperDT>

\SlotEntry <{RangeInterpreter} {FSingleton FunctionType} {\UnitSlot (DT:RangeInterpreter
) is a function which helps parse the value of \UnitSlot (S:DataRange) , which is
 used to determine the appropriate values to fill \UnitSlot (U:S) .}>
\SlotEntry <{IsTypeOf} {FSet SlotType} {Points from a datatype to those units representing
 functions whose range is composed of this datatype.}> \SFact Inverse@Datatype>

\SlotEntry <{SuperDT*} {FSet (UnitType (*P AnyDatatype))} {A list of a unit's SuperDT,
 THEIR SuperDT, etc.}> \SFact Inverse@SubDT*>
\SFact HighLevelDefn@(Starring SuperDT)>

\SlotEntry <{SubDT*} {FSet (UnitType (*P AnyDatatype))} {Transitive closure of \Unit
 (SubDT) .}> \SFact Inverse@SuperDT*>
\SFact HighLevelDefn@(Starring SubDT)>

\ClassEntry <{AnyDecomposableObject} 12 {Descendants of this are real world entities
 which consist of several subparts; and which are little more than the union of 
such pieces.}> \CFact SuperClass@AnyCT&U>
\CFact SubClass@AnyActionSequence AnyClaus>
\SlotsFor {DecomposableObject}

\SlotEntry <{ComposedOf} {FSet NonNILType} {This points to a list of the parts associated
 with this entity.}>
\ClassEntry <{AnyActionSequence} 13 {Any compound action, composed a sequence
 of subactions, descends from this unit.}> \CFact SuperClass@AnyAction AnyDecomposableObject
>
\CFact Direct Examples@DungeonAdventure Adventure Encounter>
\SlotsFor {ActionSequence}

\SlotEntry <{SubActions} {FList NonNILType} {Each action may be broken into a series
 of substeps -- each of which is a ``subaction''.}>
\ClassEntry <{AnyFormat} 14 {From this descends the units which each serve to
 describe some format; which can be used in a type description.}> \CFact SuperClass@
AnyCT&U>
\CFact SubClass@AnySlotFormat AnyValueFormat>
\SlotsFor {Format}

\SlotEntry <{FnForAdding} {FSingleton FunctionType} {One should add a new entry 
to a Ordered LIST in a different manner than one uses to add a value to an Unordered
 SET. (In the first case, multiple occurances of an element are acceptable; which
 is NOT true in the second case.) This information is contained in the function 
stored in \UnitSlot (F:FnForAdding) . Note it is used by the various {\LispFn (Add
) }ing functions -- such as the one employed to add a new entry to the existing 
value of a unit's slot.}>
\SlotEntry <{FnForDeleting} {FSingleton FunctionType} {There are different ways 
of deleting an element from a list, versus from a set. As with \Slot (FnForAdding
) , this information is stored in \UnitSlot (F:FnForDeleting) , where \Unit (F) 
\ is the name of a format.}>
\SlotEntry <{FnForKilling} {FSingleton FunctionType} {To handle indirect pointers
 using the \LispFn (*Do*) \ special slot values, one needs assistance to describe
 how to perform various manipulations -- such as deleting a full slot's value. This
 information is kept in \UnitSlot (VF:FnForKilling) , where \Unit (VF) \ is a value
 format.}>
\SlotEntry <{FnForVerifyingAll} {FSingleton FunctionType} {This is used, in conjunction
 with the various verifying functions associated with each datatype, to build the
 function stored in the \Slot (VerifyValue) \ slot of each slot. It indicates how
 to verify that a full entry is correct, given, (among other arguments,) the predicate
 to apply to each entry individually.}>
\SlotEntry <{FnForVerifyingElement} {FSingleton FunctionType} {This is used to verify
 that a single element is correct. (Perhaps this isn't used anymore -- I must look
 into this.)}>
\SlotEntry <{FormatCharacter} {FSet NonNILType} {This holds a list of specifications
 for some format. It is not currently used for anything but show.}>
\SlotEntry <{FnForGetting} {FSingleton FunctionType} {This is used to determine 
the value of a special slot value, to be returned when \LispFn (GetValue) \ requests
 its value.}>
\SlotEntry <{FnForPutting} {FSingleton FunctionType} {This indicates how to put 
a value. It is basically used for indirect pointers.}>
\ClassEntry <{AnySlotFormat} 15 {Descendants are used in type specifications,
 for processes (which include functions and slots) .}> \CFact SuperClass@AnyFormat
>
\CFact Direct Examples@FSingleton FList FSet FOrderedSet FBag FListN>

\ClassEntry <{AnyValueFormat} 16 {Descendants are used in a \LispFn (*Do*) \ 
special slot value format. This has applications as indirect pointers, as well as
 to put epistemological marks on some value.}> \CFact SuperClass@AnyFormat>
\CFact SubClass@AnyIndirectPtrFormat>
\CFact Direct Examples@FOneOf FExecute>

\ClassEntry <{AnyIndirectPtrFormat} 17 {These are used to deal with subunits,
 and other places where much data is stored at another location -- other than \UnitSlot
 (U:S) .}> \CFact SuperClass@AnyValueFormat>
\CFact Direct Examples@FSeeUnit FSeeSlot FSeeU&S>

\ClassEntry <{AnyInheritance} 18 {All modes of inheritance will descend from 
here. Associated with each instance of an inheritance is a means for creating new
 units, and constraints on properties these units may acquire. (and maybe other 
things...)}> \CFact SuperClass@AnyCT&U>
\CFact Direct Examples@IExamples ISubClass ITypEx>
\SlotsFor {Inheritance}

\SlotEntry <{UseToGetSlots} {FSingleton NonNILType} {This points to a high level
 definition of a function which is takes the parent units, and returns a list of
 units whose \Slot (NewPossibleSlots) \ slot together hold the slots which should
 be initialized in this new offspring.}>
\SlotEntry <{GetPossibleSlotsFn} {FSingleton SlotType} {This points a unit which
 represents a function, which takes the units found using the \Slot (UseToGetSlots
) \ function mentioned above, and returns a list of values with which to initialize
 a new unit. Each entry in this ordered list is a triple, consisting of the name
 of the slot, followed by the location of the relevant initializing function, and
 the typical example in which this slot was found.}> \SFact Inverse@UsedByInheritance>

\ClassEntry <{AnyOverhead} 19 {Miscellaneous information needed by CORLL, etc.,
 is stored on units which descend from here.}> \CFact SuperClass@AnyCT&U>
\CFact SubClass@AnyStatus>

\ClassEntry <{AnyStatus} 20 {This will father all *.STATUS units}> \CFact SuperClass@
AnyOverhead>
\CFact Direct Examples@GENLINFO.STATUS BIOLOGY.STATUS RLL.STATUS HOBBIT.STATUS HEURS.STATUS
 NUMBER.STATUS MATH.STATUS SETS.STATUS OLD.STATUS>
\SlotsFor {Status}

\SlotEntry <{KBsVARS} {FSingleton NonNILType} {This names a variable, whose value
 lists the variables associated with this Knowledge Base.}>
\SlotEntry <{KBsConnectedTo} {FSet (UnitType (*P AnyStatus))} {The value of { \UnitSlot
 (<kb>.STATUS:KBsConnectedTo) \ } is a list of other status units, which were resident
 in core the last time this Knowledge Base, { <kb>, } was used. It is reset whenever
 a new Knowledge Base is read in, or whenever one is disconnected or reconnected.
}> \SFact Inverse@KBsConnectedTo>

\SlotEntry <{OpenDate} {FSingleton StringType} {This holds the time stamp when this
 Knowledge Base was openned -- i.e. the start of this session.}>
\SlotEntry <{NetworkStatus} {FSingleton NonNILType} {This stores the last person
 to use this Knowledge Base, and when that last use was.}>
\SlotEntry <{WhenOpeningNetwork} {FSingleton UnrestrictedType} {This points to a
 list of functions which CORLL calls when openning this Knowledge Base. Each takes
 two arguments -- the first is the name of this KB, and the second is passed from
 \LispFn (WhenOpenningNetworks) , serves to suppress questions and messages.}>
\SlotEntry <{LoadFiles} {FSet NonNILType} {This lists the files which CORLL will
 read in whenever it opens this network. It will also ask if it should \LispFn (
MAKEFILE) \ these when this Knowledge Base is closed.}>
\SlotEntry <{KBsFNS} {FSingleton NonNILType} {This points to a variable whose value
 lists the functions relevant to this Knowledge Base.}>
\SlotEntry <{WhenWritingNetwork} {FSingleton NonNILType} {This points to a list 
of functions which CORLL calls when writing out this Knowledge Base. Each takes 
two arguments -- the first is the name of this KB, and the second is passed from
 \LispFn (WhenWritingNetworks) , serves to suppress questions and messages.}>
\SlotEntry <{Networks} {FSet KBType} {Each Knowledge Base may depend, hierarchically,
 on the presence of other knowledge bases, in core. The KBs {\Unit (<kb>) } requires
 are listed in {\UnitSlot (<kb>.STATUS:Networks) }.}>
\SlotEntry <{KBsUnitIndex} {FSingleton NonNILType} {This points to the unit which
 holds the unit index CORLL uses for this Knowledge Base.}>
\SlotEntry <{KBsFreeBlockIndex} {FSingleton NonNILType} {This points to the unit
 which holds the free block index CORLL uses for this Knowledge Base.}>
\SlotEntry <{DependentNetworks} {FSet KBType} {This lists the Knowledge Bases which
 rely on the presence of this Knowledge Base to operate.}>
\ClassEntry <{AnyProcess} 21 {Every action which takes place, in LISP, is a \LispFn
 (Process) . This corresponds to each function in LISP.}> \CFact SuperClass@AnyCT&U
>
\CFact SubClass@AnyAction AnyEuriskoProcess AnyFunction AnyUnitListProcess>
\SlotsFor {Process}

\SlotEntry <{CVUsedBy} {FSet FunctionType} {Having \Unit (x) \ in \UnitSlot (y:CVUsedBy
) \ means \Unit (x) s cached-value should be updated whenever \Unit (y) s cached-value
 changes.}> \SFact Inverse@IUseCVOf>

\SlotEntry <{DefnUsedBy} {FSet FunctionType} {Having \Unit (x) \ in \UnitSlot (y:DefnUsedBy
) \ means \Unit (x) s defn, and maybe its previously stored values, should be updated
 whenever \Unit (y) s defn changes}> \SFact Inverse@IUseDefnOf>

\SlotEntry <{WhatToProcess} {FSet UnrestrictedType} {Fill in later.}> \SFact HighLevelDefn@(OneOf TaskList RuleList)>

\SlotEntry <{IUseCVOf} {NotAFormat NotARange} {Having \Unit (y) \ in \UnitSlot (
x:IUseCVOf) \ means if the \Slot (y) \ stored value of some \Unit (z) \ should change,
 some \Unit (x) \ value may change as well.}> \SFact Inverse@CVUsedBy>
\SFact HighLevelDefn@(Apply*ingFn GetAllCVs HighLevelDefn)>

\SlotEntry <{IUseDefnOf} {NotAFormat NotARange} {Having \Unit (y) \ in \UnitSlot
 (x:IUseDefnOf) \ means \Unit (x) s defn, and maybe its previously stored values,
 should be updated whenever \Unit (y) s defn changes}> \SFact Inverse@DefnUsedBy>
\SFact HighLevelDefn@(Apply*ingFn GetAllFNS HighLevelDefn)>

\SlotEntry <{LispFn} {FSingleton FunctionType} {The actual compiled code LISP will
 run, to process a process, is stored here.}> \SFact HighLevelDefn@(OneOf LispFnForStoredFn)>

\SlotEntry <{HowToProcess} {FSingleton FunctionType} {This will soon be deleted,
 in favor of LispFn.}>
\ClassEntry <{AnyAction} 22 {This includes any activity carried out in the real
 world by physical objects.}> \CFact SuperClass@AnyProcess>
\CFact SubClass@AnyActionSequence>
\hmode{\qquad There are currently 12 examples.}\par
\SlotsFor {Action}

\SlotEntry <{SpecAct} {FSet UnitType} {This points to ``refinements'' of this action
 -- i.e. activities which are more precisely specified.}> \SFact Inverse@GenlAct>

\SlotEntry <{GenlAct} {FSet UnitType} {This points to actions which are more general
 (i.e. at a higher level of abstraction) than the action encoded by this unit. E.g.
 \Unit (Locomotions) \EPSILON \UnitSlot (Walking : GenlAct) .}> \SFact Inverse@SpecAct>

\SlotEntry <{SpecAct*} {FSet UnitType} {A list of a unit's SpecAct, THEIR SpecAct,
 etc.}> \SFact Inverse@GenlAct*>
\SFact HighLevelDefn@(Starring SpecAct)>

\SlotEntry <{GenlAct*} {FSet UnitType} {A list of a unit's GenlAct, THEIR GenlAct,
 etc.}> \SFact Inverse@SpecAct*>
\SFact HighLevelDefn@(Starring GenlAct)>

\ClassEntry <{AnyFunction} 23 {Functions are distinquished from processes in 
that the primary purpose of a function is to return a value. Note a process may 
be run, in effect, for some side effect. (Yes, this is NOT pure LISP.)}> \CFact SuperClass@
AnyProcess>
\CFact SubClass@AnyFunctional AnyMathFunction AnyPredicate AnyStorableFn AnyUnitListFn
>
\SlotsFor {Function}

\SlotEntry <{SlotsUsedInBuilding} {FSet SlotType} {Lists the slots which this one
 contributes to defining.}> \SFact Inverse@AllSBF>

\SlotEntry <{HighLevelDefn} {FSingleton NonNILType} {Here is stored a High Level
 Specification of the code to be run. This can be ``parsed'' into a piece of LISP
 code, which LISP can execute. Ideally, the information here should be sufficient
 to fully specify a function.}>
\SlotEntry <{DataRange} {FSingleton NonNILType} {The value of \UnitSlot (F:DataRange
) \ is used by the range interpreter associated with \Unit (D) , the \Slot (Datatype
) of the function \Unit (S) , to generate a function capable of deciding whether
 a value is acceptable or not.}>
\SlotEntry <{Datatype} {FSet (UnitType (*P AnyDatatype))} {\UnitSlot (S:Datatype
) \ points to the list of units in the range of the function, \Unit (F) .}> \SFact Inverse@IsTypeOf>

\SlotEntry <{Format} {FSingleton (UnitType (*P AnyFormat))} {This stores the format
 of the result this function is expected to return.}>
\SlotEntry <{DomainType} {FList NonNILType} {This holds a type specification indicating
 the domain over which this function is defined.}>
\SlotEntry <{RangeType} {FList NonNILType} {This holds a type specificiation, indicating
 the range into which this function will map.}>
\SlotEntry <{FunctionCharacter} {FSet NonNILType} {This holds facts which serve 
to describe this function. It is not currently used.}>
\SlotEntry <{Defn} {FSingleton FunctionType} {This function must take in a slot 
name \Unit (s) \ and return a function capable of reading/computing \Unit (s) \ 
in general. Ultimately, \UnitSlot (Defn:Defn) \ should have a self-compiling call
 placed in each value it returns.}> \SFact HighLevelDefn@(Apply*ingFn CAR FunctionSpec)>

\SlotEntry <{Definition} {FSingleton NonNILType} {This is not currently used; and
 may be meaningless.}>
\SlotEntry <{Domain} {FSet (UnitType (*P AnyClassOfObjects))} {This points to units,
 each of which represent a class in the domain of this function.}> \SFact Inverse@DomainOf>

\SlotEntry <{Range} {FSet (UnitType (*P AnyClassOfObjects))} {This points to units,
 which each represent a class in the range of this function.}> \SFact Inverse@RangeOf>

\SlotEntry <{IsBuiltFrom} {NotAFormat NotARange} {Appears in unit X, for a type 
of slot, and lists the old things out of which X has been defined}> \SFact HighLevelDefn@(Apply*ingFn AllButHead HighLevelDefn)>

\SlotEntry <{UnitsBuiltFrom} {NotAFormat NotARange} {This is going away soon.}> \SFact Inverse@UsedInBuilding>
\SFact HighLevelDefn@(Subsetting IsBuiltFrom Unitp)>

\SlotEntry <{UsingFunctionals} {NotAFormat NotARange} {Appears as a slot in unit
 X, and tells how X was defined out of other slots}> \SFact Inverse@CombinerFor>
\SFact HighLevelDefn@(Subsetting UsingFunctions (MemberOf AllIsas AnyFunctional))>

\SlotEntry <{SlotsBuiltFrom} {NotAFormat NotARange} {Fill in later.}> \SFact Inverse@SlotsUsedInBuilding>
\SFact HighLevelDefn@(Subsetting UnitsBuiltFrom (MemberOf AllIsas AnySlot))>

\SlotEntry <{UsingFunctions} {NotAFormat NotARange} {Appears as a slot in unit X,
 and tells how X was defined out of other slots}> \SFact HighLevelDefn@(Apply*ingFn OnlyHead HighLevelDefn)>

\SlotEntry <{FunctionSpec} {FSingleton (FunctionType)} {This function takes a slot
 name \Unit (S) , returns a list which specifies this function: The first element
 is a function capable of reading/computing \Unit (S) , in general, the second, 
the range type of this function, and the third, the domain type.}>
\SlotEntry <{PreConditions} {FSet NonNILType} {Fill in later.}>
\ClassEntry <{AnyFunctional} 24 {Each descendant unit represents a function whose
 range is a space of functions.}> \CFact SuperClass@AnyFunction>
\CFact SubClass@AnyLogicalOp AnySlotCombiner>
\CFact Direct Examples@ApplyToEach Apply*ingFn ApplyingFn MemberOf>
\SlotsFor {Functional}

\SlotEntry <{GetCVsUsed} {FSingleton FunctionType} {The value of \UnitSlot (SC:GetCVsUsed
) \ is a function which, when applied to a high level defn, HLDefn, returns a list
 of storable functions on whose cached values this HLDefn depends. (\Unit (SC) \
 is the \LispFn (CAR) \ of that HLDefn.) This computed function can then be stored
 on the function \Unit (S) , which will usually be a slot.}>
\SlotEntry <{GetFnsUsed} {FSingleton FunctionType} {The value of \UnitSlot (SC:GetFnsUsed
) \ is a function which, when applied to a high level defn, HLDefn, returns a list
 of functions on whose definition this HLDefn depends. This can then be stored on
 the function \Unit (S) , which will usually be a slot.}>
\SlotEntry <{CombinerFor} {FSet (UnitType (*P AnyFunction))} {This slot appears 
in a unit X for a type of functions, and lists those slots which are defined out
 of old ones by using X}> \SFact Inverse@UsingFunctionals>

\SlotEntry <{ToParseParts} {FSingleton FunctionType} {This value is used by each
 Slot Combiner to parse its list of arguments.}>
\ClassEntry <{AnyLogicalOp} 25 {Fill in later.}> \CFact SuperClass@AnyFunctional
>
\CFact Direct Examples@L-Optional L-NOT L-OR>

\ClassEntry <{AnySlotCombiner} 26 {An operator which takes some old slots and
 defines a new one out of them.}> 
\CFact SuperClass@AnySlotListFn AnyFunctional>
\hmode{\qquad There are currently 18 examples.}\par
\SlotsFor {SlotCombiner}

\SlotEntry <{FnForInverting} {FSingleton FunctionType} {To find the inverse of a
 slot, one can examine the high level definition of that slot, and attempt to invert
 that. The \Slot (FnForInverting) \ slot of a slot combiner, \Unit (SC) , is a function
 which takes as an argument a high level definition, and returns the high level 
definition of a slot which computes the inverse functions from the original slot.
}>
\SlotEntry <{FnForUpdating} {FSingleton FunctionType} {When a new value is placed
 in a slot, several other slots in the Knowledge Base must be updated. Such updates
 are performed by executing the code stored in the \Slot (KBUpates) \ slot of this
 slot. The \Slot (FnForUpdating) \ slot of a slot combiner is used to compute this
 \Slot (KBUpdates) . It takes a high level definition as its argument, with this
 particular slot combiner as principle slot combiner, and returns, essentially, 
the value for the \Slot (KBUpdates) \ slot for this slot (defined by that high level
 definition) .}>
\SlotEntry <{FnForCaching} {FSingleton FunctionType} {After the value of a slot 
has been computed (using the slot's definition,) RLL then considers storing that
 value away. Each slot combiner suggests an appropriate algorithm for deciding whether
 to store such values, and where. That procedure is encoded in the \Slot (FnForCaching
) \ slot of the slot combiner. (This function takes a high levgl definition as an
 argument, and returns a function to fill the \Slot (ToCache) \ slot of a slot.)
}>
\ClassEntry <{AnyPredicate} 27 {These functions return a value which is used 
as a Boolean -- i.e. they serve to intensionally define a set.}> \CFact SuperClass@
AnyFunction>

\ClassEntry <{AnyStorableFn} 28 {This class contains those functions whose value,
 on some input, might be stored, (or cached,) away. Note at least one of the arguments
 must be a unit.}> \CFact SuperClass@AnyFunction>
\CFact SubClass@AnyUnitListFn>
\SlotsFor {StorableFn}

\SlotEntry <{ToConfirmValue} {FSingleton FunctionType} {When retrieving a potential
 value for some input data, the predicate stored on this function's \Slot (ToConfirmValue
) \ slot is used to see if this value is valid.}>
\SlotEntry <{ToLookUp} {FSingleton FunctionType} {The value of this slot is a function,
 which attempts to retrieve a cached value of this function.}>
\SlotEntry <{ToCache} {FSingleton FunctionType} {The function stored here is called
 after a value has been calculated. This function then decides whether to store 
this value for future use, and if so, where.}>
\SlotEntry <{StoredAList} {FSet (FListN UnrestrictedType UnrestrictedType)} {This
 stores some i/o pairs for this function, as an association list.}>
\SlotEntry <{LispFnForStoredFn} {FSingleton FunctionType} {This function, used as
 the value for \LispFn (LispFn) , does the following: First try to find the value
 by looking it up. If that fails, compute it; and consider caching the results. 
Of course, then return the computed (or retrieved) value.}>
\ClassEntry <{AnyUnitListFn} 29 {Here will be any mapping which takes, as an 
argument, one or more units}> \CFact SuperClass@AnyStorableFn AnyFunction>
\CFact SubClass@AnySlotGetter AnySlotListFn AnyUnitFunction>

\ClassEntry <{AnySlotGetter} 30 {Examples are the units used to get the list 
of slot types which new units, created using some inheritance mechanism, should 
have.}> \CFact SuperClass@AnyUnitListFn>
\CFact Direct Examples@PossibleSlotsOfISubClass PossibleSlotsOfITypEx PossibleSlotsOfIExamples
>

\ClassEntry <{AnySlotListFn} 31 {Descendants are functions which takes one or
 more slots as arguments.}> \CFact SuperClass@AnyUnitListFn>
\CFact SubClass@AnySlotCombiner>

\ClassEntry <{AnyUnitFunction} 32 {Descendants each represent a mapping which
 takes, as an argument, a unit.}> \CFact SuperClass@AnyUnitListFn>
\CFact SubClass@Any$SELF$Slot AnySlot>
\CFact Direct Examples@ThenParts MyKB>
\SlotsFor {UnitFunction}

\SlotEntry <{HandDoneSBF} {FSet SlotType} {This is used to enter the names of slots
 (or, in general, functions,) which current slot was built from.}>
\SlotEntry <{UsingSlotCombiners} {NotAFormat NotARange} {Appears as a slot in unit
 X, and tells how X was defined out of other slots}> \SFact HighLevelDefn@(Subsetting UsingFunctionals (MemberOf AllIsas AnySlotCombiner))>

\SlotEntry <{ToGetValue} {FSingleton FunctionType} {The function stored on a function's
 \Slot (ToGetValue) is invoked when one requests \UnitSlot (x:S) .}>
\SlotEntry <{AllSBF} {FSet SlotType} {This stands for All Slots Built From . It 
is used to hold the set of all slots which affect this one -- that is, \UnitSlot
 (x:S) \ may have to be invalidated if the \Slot (y) \ slot of some unit is changed,
 whenever y \EPSILON \UnitSlot (S:AllSBF) .}> \SFact Inverse@SlotsUsedInBuilding>
\SFact HighLevelDefn@(Unioning SlotsBuiltFrom HandDoneSBF)>

\ClassEntry <{Any$SELF$Slot} 33 {Descendants of this are the oft-spoken syntactic
 slots. That is, they each refer to this unit, {\it qua} unit, rather than what 
this unit represents. See \Unit (AnyCT&U) \ and \Unit (AnyAT&U) \ to understand 
this hackery.}> \CFact SuperClass@AnyUnitFunction>
\hmode{\qquad There are currently 8 examples.}\par
\SlotsFor {$SELF$Slot}

\SlotEntry <{StoredInTypAs} {FSingleton SlotType} {This points to slot which holds
 the inheritable value in typical example units.}> \SFact Inverse@StandsForSlot>

\ClassEntry <{AnySlot} 34 {Every function which takes a unit as an argument, 
and which MAY BE STORED ON THAT UNIT, is a slot; and descends from \Unit (AnySlot
) .}> \CFact SuperClass@AnyUnitFunction>
\CFact SubClass@AnyField AnySlot-Instances PrimSlot VirtualSlot>
\CFact Direct Examples@Uncle SD Ancestor Child>
\SlotsFor {Slot}

\SlotEntry <{IsEssentialFor} {FSet UnitType} {Some virtual slots must be stored 
on a unit for bootstrapping reasons. \UnitSlot (S:IsEssentialFor) \ holds a list
 of units which require this \Slot (S) \ slot.}> \SFact Inverse@MyEssentialVirtualSlots>

\SlotEntry <{Inverse} {FSingleton SlotType} {Stating \Unit (S) \ is the \Slot (Inverse
) \ of a \Slot (T) \ means \Unit (x) \EPSILON \UnitSlot (y:S) \ iff \Unit (y) \EPSILON
 \UnitSlot (x:T) . The \EPSILON \ relation means \Unit (a) \EQUAL \Unit (b) \ if
 \Unit (b) \ is a singleton, otherwise a is in the list, b.}> \SFact Inverse@Inverse>

\SlotEntry <{OrderForToInit} {FSingleton IntegerType} {Each slot will have a value,
 stored here, which indicates at what time its ToInitialize function should be invoked
 when a new unit is being created. It may use the global variables: uParent, uInheritance,
 and uAllInheritantedSlots, to make its decision.}>
\SlotEntry <{SuperSlot} {FSet SlotType} {Stating \Unit (SS) \ is a \Slot (SuperSlot
) \ of \Slot (S) \ means the value of \UnitSlot (x:S) \ will be a subset of the 
value of \UnitSlot (x:SS) , for all \Unit (x) \ in their common range.}> \SFact Inverse@SubSlot>

\SlotEntry <{SubSlot} {FSet UnitType} {This is the inverse of \Slot (SuperSlot) 
.}> \SFact Inverse@SuperSlot>

\SlotEntry <{MakesSenseFor} {FSet (UnitType (*P AnyArchetype))} {A given slot, \Unit
 (S) , may only be defined for certain particular units. \UnitSlot (S:MakesSenseFor
) \ points to a list of typical-example units. This \Slot (S) \ slot makes sense
 for each instance of each such unit.}> \SFact Inverse@NewPossibleSlots>

\SlotEntry <{ToPutValue} {FSingleton FunctionType} {The function stored on \UnitSlot
 (S:ToPutValue) \ is called whenever putting a new value onto \UnitSlot (U:S) .}>

\SlotEntry <{ToInitialize} {FSingleton FunctionType} {When creating a new unit, 
all of the existing inheritance mechanisms first gather a collection of slots, which
 are meaningful to this new unit. Each slot, \Unit (S) , is then asked for its \UnitSlot
 (S:ToInitialize) \ function, which is then run. It is the responsibility of this
 function to actually store an appropriate value on this new unit.}>
\SlotEntry <{SuperSlot*} {FSet SlotType} {A list of a unit's SuperSlot, THEIR SuperSlot,
 etc.}> \SFact Inverse@SubSlot*>
\SFact HighLevelDefn@(Starring SuperSlot)>

\SlotEntry <{SubSlot*} {FSet UnitType} {A list of a unit's SubSlot, THEIR SubSlot,
 etc.}> \SFact Inverse@SuperSlot*>
\SFact HighLevelDefn@(Starring SubSlot)>

\SlotEntry <{ToAddValue} {FSingleton FunctionType} {Whenever one wishes to add one
 a value to the current value of \UnitSlot (U:S) , the function stored on \UnitSlot
 (S:ToAddValue) \ is called.}>
\SlotEntry <{ToDeleteValue} {FSingleton FunctionType} {Whenever one wants to delete
 a value from the list of values stored on \UnitSlot (U:S) , the function stored
 on \UnitSlot (S:ToDeleteValue) \ is called.}>
\SlotEntry <{ToSubstValue} {FSingleton FunctionType} {Whenever one wants to substitute
 one value for another, on the list of values stored on \UnitSlot (U:S) , the function
 stored on \UnitSlot (S:ToSubstValue) \ is called.}>
\SlotEntry <{KBUpdates} {FSingleton FunctionType} {Whenever a value is stored in
 a slot, various changed must be made throughout the Knowledge Bases, for truth 
maintanence reasons. A function designed to perform such modifications is stored
 in the \Slot (KBUpdates) \ slot of each slot. \UnitSlot (S:KBUpdates) \ is called
 whenever the value of \UnitSlot (x:S) \ is changed. \par This \Slot (KBUpdates)
 \ is calculated using the \Unit (FnForUpdating) \ slots of the various Slot Combiners
 used to define this \Unit (S) \ slot.}>
\SlotEntry <{VerifyAll} {FSingleton FunctionType} {Before accepting a value for 
storage on \UnitSlot (U:S) , it is tested for acceptability. This is done by calling
 \UnitSlot (S:VerifyAll) \ on this proposed value.}>
\SlotEntry <{VerifyElement} {FSingleton FunctionType} {When adding a new value to
 a slot's existing value, or substituting one value for another, it is often costly,
 and unnecessary, to check all of the values for acceptability. To verify the validity
 of one value, the function stored on \UnitSlot (S:VerifyElement) \ is called on
 that proposed new element.}>
\ClassEntry <{AnyField} 35 {Slots on sub-units (that is, units devoted to storing
 the value of a slot of a given unit,) are called fields. Those ``slots'' which 
appear only in this context are stored under \Unit (AnyField) .}> \CFact SuperClass@
AnySlot>
\CFact Direct Examples@*vaLue* LivesInLocation LivesInSlot LivesInUnit>

\ClassEntry <{AnySlot-Instances} 36 {Aliases used for syntactic slots are stored
 under \Unit (AnySlot-Instances) . These are used to hold values which should be
 inherited from typical example units; freeing the basic slot to hold the value 
pertanent to this particular unit.}> \CFact SuperClass@AnySlot>
\CFact Direct Examples@SlotsNowOrdered-Instances EssentialVirtualSlots-Instances
 ToKillMe-Instances ToRenameMe-Instances>
\SlotsFor {Slot-Instances}

\SlotEntry <{StandsForSlot} {FSingleton SlotType} {This points to the name of the
 syntactic slot for which this is an alias.}> \SFact Inverse@StoredInTypAs>

\ClassEntry <{PrimSlot} 37 {Primitive slots, which descend from this \Unit (AnyPrimSlot
) , cannot be computed if omitted. (As opposed to virtual slots, which are technically
 redundant information, as they can be computed from more basic slots.)}> \CFact SuperClass@
AnySlot>
\CFact SubClass@AnyAccessSlot AnyActionPartOfRule AnyFormatFnSlot CharacterAbility
>
\hmode{\qquad There are currently 105 examples.}\par

\ClassEntry <{AnyAccessSlot} 38 {Descendant of this \Unit (AnyAccessSlot) \ are
 slots used to manipulate the units themselves. For efficiency, they all use the
 same fast retrieval mechanism to determine their respective values -- \LispFn (
GetAccessFn) .}> \CFact SuperClass@PrimSlot>
\CFact Direct Examples@ToGetValue BeforeGetValue AfterGetValue ToPutValue BeforePutValue
 AfterPutValue ToAddValue ToDeleteValue ToSubstValue ToInitialize MyToKillMe ToCacheField
 ToCache ToKillValue MyToRenameMe>

\ClassEntry <{AnyFormatFnSlot} 39 {Various bits of information are associated
 with each format. When this information is functional, it descends from this \Unit
 (AnyFormatFnSlot) .}> \CFact SuperClass@PrimSlot>
\hmode{\qquad There are currently 8 examples.}\par

\ClassEntry <{VirtualSlot} 40 {These slots are redundant, as they could have 
been computed from other, more basic slots. (Modulo Garden-Of-Eden conditions. See
 \Unit (MyEssentialVirtualSlots) .)}> \CFact SuperClass@AnySlot>
\hmode{\qquad There are currently 115 examples.}\par

\ClassEntry <{AnyUnitListProcess} 41 {These processes take one or more units 
(amoung possibly other things) are arguments.}> \CFact SuperClass@AnyProcess>
\CFact SubClass@AnyUnitProcess>

\ClassEntry <{AnyUnitProcess} 42 {These processes take a single unit as its argument.
}> \CFact SuperClass@AnyUnitListProcess>
\CFact Direct Examples@EditUnit>

\ClassEntry <{AnyUnit} 43 {Examples will be things which REPRESENT units... NOTE:
 this does NOT include every unit automatically! (In fact, most units represent 
some real world object, such as Tree$\#$32, or some conceptual entity, such as Red,
 or Function$\#$412.)}> \CFact SuperClass@Anything>
\SlotsFor {Unit}

\SlotEntry <{MyCreatedAs} {FListN (UnitType (*P AnyInheritance)) (FList UnitType
)} {This stores inheritance information about this unit -- indicating, for example,
 that it was created as an \Unit (IExamples) \ (read ``Example'') of \Unit (AnySlot
) .}>
\SlotEntry <{MyEssentialVirtualSlots} {FSet SlotType} {These slots are essential
 for the Garden of Eden RLL system. Therefore \LispFn (RemoveVirtualSlots) \ is 
smart enough to know NOT to remove these slots (i.e. those which \Slot (MyEssentialVirtualSlots
) \ points to) from a unit.}> \SFact Inverse@IsEssentialFor>

\SlotEntry <{MyToRenameMe} {FSingleton FunctionType} {This function is called when
 renaming this unit to another name.}>
\SlotEntry <{MyTimeOfCreation} {FSingleton StringType} {This records when this unit
 was created.}>
\SlotEntry <{MyCreator} {FSingleton StringType} {This names the user who created
 this unit.}>
\SlotEntry <{MyToKillMe} {FSingleton FunctionType} {This function is called when
 deleting this unit.}>
\SlotEntry <{MySlotsNowOrdered} {FSet SlotType} {This lists the names of slots which
 are currently in the correct order. (For example, \Slot (OrderedPrototypes) \ appears
 in some unit's \Slot (MyEssentialVirtualSlots) \ only when the typical example 
units stored in \Slot (Prototypes) \ have been arranged in the correct order.)}>

\SlotEntry <{MySensibleSlots} {FSet SlotType} {Only certain slots are defined for
 a given unit. This list is stored in that unit's \Slot (MySensibleSlots) .}> \SFact HighLevelDefn@(Composition NewPossibleSlots Prototypes)>

\SlotEntry <{MySlots} {FSet SlotType} {This never cached slot returns the list of
 slots belonging to this unit.}> \SFact Inverse@AmUsedIn>

\ClassEntry <{AnyUser} 44 {RLL tries to hold some primitive information about
 each user of this system. A unit is devoted to each user, (as well as each recognized
 user class) ; and this information is under \Unit (AnyUser) .}> \CFact SuperClass@
AnyCT&U>
\CFact SubClass@AnyHacker>
\CFact Direct Examples@AndyFreeman LarryHines>
\SlotsFor {User}

\SlotEntry <{InformalName} {FSingleton StringType} {This is a name RLL can use to
 greet this user.}>
\SlotEntry <{UsualKBs} {FSet KBType} {These are the Knowledge Bases this user usually
 wants loaded in.}>
\SlotEntry <{WritingOptions} {FList NonNILType} {When closing a Knowledge Base, 
RLL must ask the user several questions. To sidestep this tedious (and often unneccessary
) process, the user can indicate a fixed set of responses to such inquires; which
 are stored on this \Slot (WritingOptions) \ slot. When closing the KBs, the user
 is now asked a single question -- if he wishes to use these. (Answering No forces
 RLL to ask him these questions one by one.) \par The defaulted writing function,
 \LispFn (StandardFinishUp) , asks if virtual slots should be removed, if this KB
 should be disconnected from the others, and if this KB should be diagnosed; in 
that order. Setting \Slot (WritingOptions) \ to (Y N Y) instructs RLL to remove 
virtual slots, and diagnose the KB, but not to disconnect it.}>
\SlotEntry <{OpenningOptions} {FList UnrestrictedType} {Like \Slot (WritingOptions
) , this helps the user to avoid a potentially dull task. The value stored here 
will be handed to the function called when openning each knowledge base; if the 
user indicates he wishes his default setting to be used. \par The only question 
\LispFn (StandardStartUp) \ might ask is whethr to reconnect an enterring knowledge
 base. Setting the \Slot (OpenningOptions) \ slot to (NIL) means this question will
 be asked each time.}>
\SlotEntry <{UserNames} {FSet StringType} {This lists the system names this user
 may go by. (Ie values of \LispFn ({ (USERNAME) }) \ which correspond to this person.
)}>
\ClassEntry <{AnyHacker} 45 {This class includes people working on RLL.}> \CFact SuperClass@
AnyUser>
\CFact Direct Examples@DougLenat RussGreiner>

\ClassEntry <{AnyConcreteThing} 46 {Instances refer to tangible objects, (such
 as trees,) as opposed to abstract things (such as variables) .}> \CFact SuperClass@
Anything>

\StartIndex
\IS <*vaLue*   6>
\IS <AllExamples 10>
\IS <AllGenls 1>
\IS <AllIsas 1>
\IS <AllSBF 32>
\IS <AllSpecs 1>
\IU <Any$SELF$Slot 33>
\IU <AnyAT&U 2>
\IU <AnyAbstractThing 8>
\IU <AnyAccessSlot 38>
\IU <AnyAction 22>
\IU <AnyActionSequence 13>
\IU <AnyArchetype 4>
\IU <AnyCT&U 9>
\IU <AnyClassOfObjects 10>
\IU <AnyConcreteThing 46>
\IU <AnyDatatype 11>
\IU <AnyDecomposableObject 12>
\IU <AnyDescriptor 5>
\IU <AnyField 35>
\IU <AnyFormat 14>
\IU <AnyFormatFnSlot 39>
\IU <AnyFunction 23>
\IU <AnyFunctional 24>
\IU <AnyHacker 45>
\IU <AnyIndirectPtrFormat 17>
\IU <AnyInheritance 18>
\IU <AnyIntensionalObject 3>
\IU <AnyLogicalOp 25>
\IU <AnyOverhead 19>
\IU <AnyPredicate 27>
\IU <AnyProcess 21>
\IU <AnySlot 34>
\IU <AnySlot-Instances 36>
\IU <AnySlotCombiner 26>
\IU <AnySlotFormat 15>
\IU <AnySlotGetter 30>
\IU <AnySlotListFn 31>
\IU <AnyStatus 20>
\IU <AnyStorableFn 28>
\IU <AnyUnit 43>
\IU <AnyUnitForSlot 6>
\IU <AnyUnitFunction 32>
\IU <AnyUnitListFn 29>
\IU <AnyUnitListProcess 41>
\IU <AnyUnitProcess 42>
\IU <AnyUser 44>
\IU <AnyValueFormat 16>
\IU <AnyVariable 7>
\IU <Anything 1>
\IS <CVUsedBy 21>
\IS <Characteristics 1>
\IS <CombinerFor 24>
\IS <ComposedOf 12>
\IS <DataRange 23>
\IS <Datatype 23>
\IS <Definition 23>
\IS <Defn 23>
\IS <DefnUsedBy 21>
\IS <DependentNetworks 20>
\IS <Descr 1>
\IS <Domain 23>
\IS <DomainOf 10>
\IS <DomainType 23>
\IS <EqualDTSpec 11>
\IS <Examples 10>
\IS <FnForAdding 14>
\IS <FnForCaching 26>
\IS <FnForDeleting 14>
\IS <FnForGetting 14>
\IS <FnForInverting 26>
\IS <FnForKilling 14>
\IS <FnForPutting 14>
\IS <FnForUpdating 26>
\IS <FnForVerifyingAll 14>
\IS <FnForVerifyingElement 14>
\IS <Format 23>
\IS <FormatCharacter 14>
\IS <FunctionCharacter 23>
\IS <FunctionSpec 23>
\IS <GenerateAll 11>
\IS <GenlAct 22>
\IS <GenlAct* 22>
\IS <GenlsModels 10>
\IS <GetCVsUsed 24>
\IS <GetFnsUsed 24>
\IS <GetPossibleSlotsFn 18>
\IS <HandDoneSBF 32>
\IS <HighLevelDefn 23>
\IS <HowToProcess 21>
\IS <IUseCVOf 21>
\IS <IUseDefnOf 21>
\IS <InformalName 44>
\IS <IntensionalExamples 10>
\IS <Inverse 34>
\IS <IsBuiltFrom 23>
\IS <IsEssentialFor 34>
\IS <IsTypeOf 11>
\IS <Isa 1>
\IS <KBUpdates 34>
\IS <KBsConnectedTo 20>
\IS <KBsFNS 20>
\IS <KBsFreeBlockIndex 20>
\IS <KBsUnitIndex 20>
\IS <KBsVARS 20>
\IS <LispFn 21>
\IS <LispFnForStoredFn 28>
\IS <LoadFiles 20>
\IS <MakesSenseFor 34>
\IS <MyCreatedAs 43>
\IS <MyCreator 43>
\IS <MyEssentialVirtualSlots 43>
\IS <MySensibleSlots 43>
\IS <MySlots 43>
\IS <MySlotsNowOrdered 43>
\IS <MyTimeOfCreation 43>
\IS <MyToKillMe 43>
\IS <MyToRenameMe 43>
\IS <NetworkStatus 20>
\IS <Networks 20>
\IS <NewPossibleSlots 4>
\IS <OpenDate 20>
\IS <OpenningOptions 44>
\IS <OrderForToInit 34>
\IS <OrderedPrototypes 1>
\IS <PossibleSlots 4>
\IS <PreConditions 23>
\IU <PrimSlot 37>
\IS <Prototypes 1>
\IS <Range 23>
\IS <RangeInterpreter 11>
\IS <RangeOf 10>
\IS <RangeType 23>
\IS <SlotsBuiltFrom 23>
\IS <SlotsUsedInBuilding 23>
\IS <SpecAct 22>
\IS <SpecAct* 22>
\IS <Specializations 1>
\IS <StandsForSlot 36>
\IS <StdExamples 10>
\IS <StoredAList 28>
\IS <StoredInTypAs 33>
\IS <SubActions 13>
\IS <SubClass 10>
\IS <SubClass* 10>
\IS <SubDT 11>
\IS <SubDT* 11>
\IS <SubSlot 34>
\IS <SubSlot* 34>
\IS <SubTypEx 4>
\IS <SubTypEx* 4>
\IS <SuperClass 10>
\IS <SuperClass* 10>
\IS <SuperDT 11>
\IS <SuperDT* 11>
\IS <SuperSlot 34>
\IS <SuperSlot* 34>
\IS <SuperTypEx 4>
\IS <SuperTypEx* 4>
\IS <ToAddValue 34>
\IS <ToCache 28>
\IS <ToConfirmValue 28>
\IS <ToDeleteValue 34>
\IS <ToGetValue 32>
\IS <ToInitialize 34>
\IS <ToLookUp 28>
\IS <ToParseParts 24>
\IS <ToPutValue 34>
\IS <ToSubstValue 34>
\IS <TotalSoFar 10>
\IS <TypicalExample 10>
\IS <TypicalExampleOf 4>
\IS <UnitsBuiltFrom 23>
\IS <UseToGetSlots 18>
\IS <UserNames 44>
\IS <UsingFunctionals 23>
\IS <UsingFunctions 23>
\IS <UsingSlotCombiners 32>
\IS <UsualKBs 44>
\IS <VerifyAll 34>
\IS <VerifyElement 34>
\IS <VerifyType 11>
\IU <VirtualSlot 40>
\IS <WhatToProcess 21>
\IS <WhenOpeningNetwork 20>
\IS <WhenWritingNetwork 20>
\IS <WritingOptions 44>
\par\vfill\eject\end